[INFO] fetching crate dgraph-rs 0.2.8...
[INFO] fixing dgraph-rs-0.2.8 against try#622891a4e29178280638a6b63a8908bde2c0c854+cargoflags=-Zfix-edition=end=2015,2024 for pr-157817-2
[INFO] extracting crate dgraph-rs 0.2.8 into /workspace/builds/worker-3-tc2/source
[INFO] started tweaking crates.io crate dgraph-rs 0.2.8
[INFO] finished tweaking crates.io crate dgraph-rs 0.2.8
[INFO] tweaked toml for crates.io crate dgraph-rs 0.2.8 written to /workspace/builds/worker-3-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate dgraph-rs 0.2.8 on toolchain 622891a4e29178280638a6b63a8908bde2c0c854
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]      Locking 139 packages to latest compatible versions
[INFO] [stderr]       Adding async-std v1.0.1 (available: v1.13.2)
[INFO] [stderr]       Adding grpc v0.6.2 (available: v0.9.0)
[INFO] [stderr]       Adding httpbis v0.7.0 (available: v0.9.1)
[INFO] [stderr]       Adding protobuf v2.8.2 (available: v2.28.0)
[INFO] [stderr]       Adding protobuf-codegen v2.8.2 (available: v2.28.0)
[INFO] [stderr]       Adding protoc v2.8.2 (available: v2.28.0)
[INFO] [stderr]       Adding protoc-rust v2.8.2 (available: v2.28.0)
[INFO] [stderr]       Adding protoc-rust-grpc v0.6.2 (available: v0.8.3)
[INFO] [stderr]       Adding rand v0.7.3 (available: v0.10.1)
[INFO] [stderr]       Adding rand_xoshiro v0.4.0 (available: v0.8.1)
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/source:/opt/rustwide/workdir:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:3a6becf2bc8dde7f3fa57ede90e4f284e72d296796fc446bbb1e2c7cc0530151" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] f20f0ad1249e0cb79f7941d291ebc3ef7f15f225348a0d5d76aaeb728285a799
[INFO] running `Command { std: "docker" "start" "f20f0ad1249e0cb79f7941d291ebc3ef7f15f225348a0d5d76aaeb728285a799", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-w" "/opt/rustwide/workdir" "--user" "0:0" "f20f0ad1249e0cb79f7941d291ebc3ef7f15f225348a0d5d76aaeb728285a799" "/opt/rustwide/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "f20f0ad1249e0cb79f7941d291ebc3ef7f15f225348a0d5d76aaeb728285a799", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=" "-e" "RUSTDOCFLAGS=" "-w" "/opt/rustwide/workdir" "--user" "0:0" "f20f0ad1249e0cb79f7941d291ebc3ef7f15f225348a0d5d76aaeb728285a799" "/opt/rustwide/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "fix" "--allow-no-vcs" "--allow-dirty" "--frozen" "--all" "--all-targets" "--message-format=json" "-Zfix-edition=end=2015,2024", kill_on_drop: false }`
[INFO] [stderr] crater-edition-check: migrating to next edition
[INFO] [stderr]    Migrating Cargo.toml from 2018 edition to 2021
[INFO] [stderr] note: Switching to Edition 2021 will enable the use of the version 2 feature resolver in Cargo.
[INFO] [stderr] This may cause some dependencies to be built with fewer features enabled than previously.
[INFO] [stderr] More information about the resolver changes may be found at https://doc.rust-lang.org/nightly/edition-guide/rust-2021/default-cargo-resolver.html
[INFO] [stderr] When building the following dependencies, the given features will no longer be used:
[INFO] [stderr] 
[INFO] [stderr]   futures-core v0.3.32 removed features: default
[INFO] [stderr]   futures-io v0.3.32 removed features: default
[INFO] [stderr]   log v0.4.33 removed features: kv, kv_unstable, value-bag
[INFO] [stderr]   log v0.4.33 (as host dependency) removed features: kv, kv_unstable, std, value-bag
[INFO] [stderr]   once_cell v1.21.4 (as host dependency) removed features: default
[INFO] [stderr]   protobuf v2.8.2 (as host dependency) removed features: bytes, with-bytes
[INFO] [stderr] 
[INFO] [stderr]     Checking cfg-if v0.1.10
[INFO] [stderr]     Checking futures v0.1.31
[INFO] [stderr]     Checking value-bag v1.12.0
[INFO] [stderr]    Compiling maybe-uninit v2.0.0
[INFO] [stderr]    Compiling semver-parser v0.7.0
[INFO] [stderr]    Compiling protobuf v2.8.2
[INFO] [stderr]    Compiling byteorder v1.5.0
[INFO] [stderr]    Compiling crossbeam-utils v0.7.2
[INFO] [stderr]    Compiling memoffset v0.5.6
[INFO] [stderr]    Compiling crossbeam-epoch v0.8.2
[INFO] [stderr]     Checking lock_api v0.3.4
[INFO] [stderr]     Checking iovec v0.1.4
[INFO] [stderr]     Checking num_cpus v1.17.0
[INFO] [stderr]    Compiling linux-raw-sys v0.12.1
[INFO] [stderr]     Checking net2 v0.2.39
[INFO] [stderr]     Checking bytes v0.4.12
[INFO] [stderr]    Compiling getrandom v0.1.16
[INFO] [stderr]    Compiling getrandom v0.4.3
[INFO] [stderr]    Compiling fastrand v2.4.1
[INFO] [stderr]    Compiling rand v0.4.6
[INFO] [stderr]    Compiling remove_dir_all v0.5.3
[INFO] [stderr]     Checking futures-sink v0.3.32
[INFO] [stderr]     Checking scoped-tls v0.1.2
[INFO] [stderr]     Checking futures-channel v0.3.32
[INFO] [stderr]    Compiling futures-macro v0.3.32
[INFO] [stderr]     Checking zerocopy v0.8.52
[INFO] [stderr]     Checking log v0.4.33
[INFO] [stderr]    Compiling httpbis v0.7.0
[INFO] [stderr]    Compiling semver v0.9.0
[INFO] [stderr]     Checking smallvec v0.6.14
[INFO] [stderr]     Checking void v1.0.2
[INFO] [stderr]     Checking slab v0.3.0
[INFO] [stderr]     Checking unix_socket v0.5.0
[INFO] [stderr]    Compiling rustix v1.1.4
[INFO] [stderr]     Checking futures-core-preview v0.3.0-alpha.19
[INFO] [stderr]     Checking safemem v0.3.3
[INFO] [stderr]     Checking mio v0.6.23
[INFO] [stderr]     Checking tls-api v0.1.22
[INFO] [stderr]     Checking log v0.3.9
[INFO] [stderr]     Checking base64 v0.9.3
[INFO] [stderr]     Checking rand_core v0.5.1
[INFO] [stderr]     Checking crossbeam-utils v0.6.6
[INFO] [stderr]     Checking serde_json v1.0.150
[INFO] [stderr]    Compiling rustc_version v0.2.3
[INFO] [stderr]     Checking tls-api-stub v0.1.22
[INFO] [stderr]     Checking crossbeam-queue v0.2.3
[INFO] [stderr]    Compiling protoc v2.8.2
[INFO] [stderr]     Checking rand_xoshiro v0.4.0
[INFO] [stderr]     Checking async-macros v1.0.0
[INFO] [stderr]     Checking futures-timer v1.0.3
[INFO] [stderr]     Checking kv-log-macro v1.0.7
[INFO] [stderr]     Checking crossbeam-channel v0.3.9
[INFO] [stderr]     Checking async-task v1.3.1
[INFO] [stderr]    Compiling parking_lot_core v0.6.3
[INFO] [stderr]    Compiling parking_lot v0.9.0
[INFO] [stderr]     Checking crossbeam-deque v0.7.4
[INFO] [stderr]    Compiling tempdir v0.3.7
[INFO] [stderr]     Checking pin-project-lite v0.1.12
[INFO] [stderr]     Checking mio-uds v0.6.8
[INFO] [stderr]     Checking async-std v1.0.1
[INFO] [stderr]     Checking tokio-executor v0.1.10
[INFO] [stderr]     Checking tokio-io v0.1.13
[INFO] [stderr]     Checking tokio-sync v0.1.8
[INFO] [stderr]     Checking futures-cpupool v0.1.8
[INFO] [stderr]     Checking futures-util v0.3.32
[INFO] [stderr]     Checking tokio-timer v0.1.2
[INFO] [stderr]     Checking tokio-threadpool v0.1.18
[INFO] [stderr]     Checking tokio-current-thread v0.1.7
[INFO] [stderr]     Checking tokio-timer v0.2.13
[INFO] [stderr]     Checking tokio-reactor v0.1.12
[INFO] [stderr]     Checking tokio-codec v0.1.2
[INFO] [stderr]     Checking tokio-fs v0.1.7
[INFO] [stderr]     Checking tokio-tls-api v0.1.22
[INFO] [stderr]     Checking tokio-uds v0.2.7
[INFO] [stderr]     Checking tokio-tcp v0.1.4
[INFO] [stderr]     Checking tokio-udp v0.1.6
[INFO] [stderr]     Checking tokio v0.1.22
[INFO] [stderr]     Checking tokio-core v0.1.18
[INFO] [stderr]    Compiling tempfile v3.27.0
[INFO] [stderr]     Checking tokio-uds v0.1.7
[INFO] [stderr]     Checking grpc v0.6.2
[INFO] [stderr]     Checking ppv-lite86 v0.2.21
[INFO] [stderr]     Checking rand_chacha v0.2.2
[INFO] [stderr]     Checking rand v0.7.3
[INFO] [stderr]    Compiling protobuf-codegen v2.8.2
[INFO] [stderr]     Checking futures-executor v0.3.32
[INFO] [stderr]     Checking futures v0.3.32
[INFO] [stderr]    Compiling grpc-compiler v0.6.2
[INFO] [stderr]    Compiling protoc-rust v2.8.2
[INFO] [stderr]    Compiling protoc-rust-grpc v0.6.2
[INFO] [stderr]    Compiling dgraph-rs v0.2.8 (/opt/rustwide/workdir)
[INFO] [stderr]    Migrating build.rs from 2018 edition to 2021
[INFO] [stderr]    Migrating src/lib.rs from 2018 edition to 2021
[INFO] [stderr]     Finished `dev` profile [unoptimized + debuginfo] target(s) in 23.63s
[INFO] [stderr] crater-edition-check: dgraph-rs v0.2.8 (/opt/rustwide/workdir) updating edition from 2018 to 2021
[INFO] [stderr]    Compiling protobuf v2.8.2
[INFO] [stderr]    Compiling once_cell v1.21.4
[INFO] [stderr]    Compiling protoc v2.8.2
[INFO] [stderr]    Compiling tempfile v3.27.0
[INFO] [stderr]    Compiling protobuf-codegen v2.8.2
[INFO] [stderr]    Compiling protoc-rust v2.8.2
[INFO] [stderr]    Compiling grpc-compiler v0.6.2
[INFO] [stderr]    Compiling protoc-rust-grpc v0.6.2
[INFO] [stderr]    Compiling dgraph-rs v0.2.8 (/opt/rustwide/workdir)
[INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]   --> src/lib.rs:41:20
[INFO] [stdout]    |
[INFO] [stdout] 41 |     pub fn new_txn(&self) -> Txn {
[INFO] [stdout]    |                    ^^^^^     ^^^ the same lifetime is hidden here
[INFO] [stdout]    |                    |
[INFO] [stdout]    |                    the lifetime is elided here
[INFO] [stdout]    |
[INFO] [stdout]    = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
[INFO] [stdout]    = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default
[INFO] [stdout] help: use `'_` for type paths
[INFO] [stdout]    |
[INFO] [stdout] 41 |     pub fn new_txn(&self) -> Txn<'_> {
[INFO] [stdout]    |                                 ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]   --> src/lib.rs:53:26
[INFO] [stdout]    |
[INFO] [stdout] 53 |     pub fn new_read_only(&self) -> Txn {
[INFO] [stdout]    |                          ^^^^^     ^^^ the same lifetime is hidden here
[INFO] [stdout]    |                          |
[INFO] [stdout]    |                          the lifetime is elided here
[INFO] [stdout]    |
[INFO] [stdout]    = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
[INFO] [stdout] help: use `'_` for type paths
[INFO] [stdout]    |
[INFO] [stdout] 53 |     pub fn new_read_only(&self) -> Txn<'_> {
[INFO] [stdout]    |                                       ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]   --> src/lib.rs:65:28
[INFO] [stdout]    |
[INFO] [stdout] 65 |     pub fn new_best_effort(&self) -> Txn {
[INFO] [stdout]    |                            ^^^^^     ^^^ the same lifetime is hidden here
[INFO] [stdout]    |                            |
[INFO] [stdout]    |                            the lifetime is elided here
[INFO] [stdout]    |
[INFO] [stdout]    = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
[INFO] [stdout] help: use `'_` for type paths
[INFO] [stdout]    |
[INFO] [stdout] 65 |     pub fn new_best_effort(&self) -> Txn<'_> {
[INFO] [stdout]    |                                         ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]   --> src/lib.rs:41:20
[INFO] [stdout]    |
[INFO] [stdout] 41 |     pub fn new_txn(&self) -> Txn {
[INFO] [stdout]    |                    ^^^^^     ^^^ the same lifetime is hidden here
[INFO] [stdout]    |                    |
[INFO] [stdout]    |                    the lifetime is elided here
[INFO] [stdout]    |
[INFO] [stdout]    = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
[INFO] [stdout]    = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default
[INFO] [stdout] help: use `'_` for type paths
[INFO] [stdout]    |
[INFO] [stdout] 41 |     pub fn new_txn(&self) -> Txn<'_> {
[INFO] [stdout]    |                                 ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]   --> src/lib.rs:53:26
[INFO] [stdout]    |
[INFO] [stdout] 53 |     pub fn new_read_only(&self) -> Txn {
[INFO] [stdout]    |                          ^^^^^     ^^^ the same lifetime is hidden here
[INFO] [stdout]    |                          |
[INFO] [stdout]    |                          the lifetime is elided here
[INFO] [stdout]    |
[INFO] [stdout]    = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
[INFO] [stdout] help: use `'_` for type paths
[INFO] [stdout]    |
[INFO] [stdout] 53 |     pub fn new_read_only(&self) -> Txn<'_> {
[INFO] [stdout]    |                                       ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]   --> src/lib.rs:65:28
[INFO] [stdout]    |
[INFO] [stdout] 65 |     pub fn new_best_effort(&self) -> Txn {
[INFO] [stdout]    |                            ^^^^^     ^^^ the same lifetime is hidden here
[INFO] [stdout]    |                            |
[INFO] [stdout]    |                            the lifetime is elided here
[INFO] [stdout]    |
[INFO] [stdout]    = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
[INFO] [stdout] help: use `'_` for type paths
[INFO] [stdout]    |
[INFO] [stdout] 65 |     pub fn new_best_effort(&self) -> Txn<'_> {
[INFO] [stdout]    |                                         ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished `dev` profile [unoptimized + debuginfo] target(s) in 30.55s
[INFO] [stderr] crater-edition-check: migrating to next edition
[INFO] [stderr]    Migrating Cargo.toml from 2018 edition to 2021
[INFO] [stderr] note: Switching to Edition 2021 will enable the use of the version 2 feature resolver in Cargo.
[INFO] [stderr] This may cause some dependencies to be built with fewer features enabled than previously.
[INFO] [stderr] More information about the resolver changes may be found at https://doc.rust-lang.org/nightly/edition-guide/rust-2021/default-cargo-resolver.html
[INFO] [stderr] When building the following dependencies, the given features will no longer be used:
[INFO] [stderr] 
[INFO] [stderr]   futures-core v0.3.32 removed features: default
[INFO] [stderr]   futures-io v0.3.32 removed features: default
[INFO] [stderr]   log v0.4.33 removed features: kv, kv_unstable, value-bag
[INFO] [stderr]   log v0.4.33 (as host dependency) removed features: kv, kv_unstable, std, value-bag
[INFO] [stderr]   once_cell v1.21.4 (as host dependency) removed features: default
[INFO] [stderr]   protobuf v2.8.2 (as host dependency) removed features: bytes, with-bytes
[INFO] [stderr] 
[INFO] [stderr]     Checking dgraph-rs v0.2.8 (/opt/rustwide/workdir)
[INFO] [stderr]    Migrating src/lib.rs from 2021 edition to 2024
[INFO] [stderr]        Fixed src/lib.rs (1 fix)
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:342:13
[INFO] [stdout]     |
[INFO] [stdout] 342 | /             descriptor.get(|| {
[INFO] [stdout] 343 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 344 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
[INFO] [stdout] 345 | |                     "start_ts",
[INFO] [stdout] ...   |
[INFO] [stdout] 384 | |             })
[INFO] [stdout]     | |______________^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout]     = note: `--force-warn static-mut-refs` implied by `--force-warn rust-2024-compatibility`
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 337 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 337 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:394:13
[INFO] [stdout]     |
[INFO] [stdout] 394 |             instance.get(Request::new)
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 389 -         static mut instance: ::protobuf::lazy::Lazy<Request> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 389 +         static instance: ::protobuf::lazy::Lazy<Request> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:546:13
[INFO] [stdout]     |
[INFO] [stdout] 546 | /             descriptor.get(|| {
[INFO] [stdout] 547 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 548 | |                 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 549 | |                     "uids",
[INFO] [stdout] ...   |
[INFO] [stdout] 558 | |             })
[INFO] [stdout]     | |______________^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 541 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 541 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:568:13
[INFO] [stdout]     |
[INFO] [stdout] 568 |             instance.get(Uids::new)
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 563 -         static mut instance: ::protobuf::lazy::Lazy<Uids> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 563 +         static instance: ::protobuf::lazy::Lazy<Uids> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:899:13
[INFO] [stdout]     |
[INFO] [stdout] 899 | /             descriptor.get(|| {
[INFO] [stdout] 900 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 901 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
[INFO] [stdout] 902 | |                     "json",
[INFO] [stdout] ...   |
[INFO] [stdout] 931 | |             })
[INFO] [stdout]     | |______________^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 894 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 894 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:941:13
[INFO] [stdout]     |
[INFO] [stdout] 941 |             instance.get(Response::new)
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 936 -         static mut instance: ::protobuf::lazy::Lazy<Response> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 936 +         static instance: ::protobuf::lazy::Lazy<Response> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1351:13
[INFO] [stdout]      |
[INFO] [stdout] 1351 | /             descriptor.get(|| {
[INFO] [stdout] 1352 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 1353 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
[INFO] [stdout] 1354 | |                     "set_json",
[INFO] [stdout] ...    |
[INFO] [stdout] 1398 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1346 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1346 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1408:13
[INFO] [stdout]      |
[INFO] [stdout] 1408 |             instance.get(Mutation::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1403 -         static mut instance: ::protobuf::lazy::Lazy<Mutation> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1403 +         static instance: ::protobuf::lazy::Lazy<Mutation> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1688:13
[INFO] [stdout]      |
[INFO] [stdout] 1688 | /             descriptor.get(|| {
[INFO] [stdout] 1689 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 1690 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 1691 | |                     "schema",
[INFO] [stdout] ...    |
[INFO] [stdout] 1720 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1683 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1683 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1730:13
[INFO] [stdout]      |
[INFO] [stdout] 1730 |             instance.get(Operation::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1725 -         static mut instance: ::protobuf::lazy::Lazy<Operation> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1725 +         static instance: ::protobuf::lazy::Lazy<Operation> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1800:13
[INFO] [stdout]      |
[INFO] [stdout] 1800 | /             descriptor.get(|| {
[INFO] [stdout] 1801 | |                 ::protobuf::reflect::EnumDescriptor::new("Operation_DropOp", file_descriptor_proto())
[INFO] [stdout] 1802 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1795 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1795 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1945:13
[INFO] [stdout]      |
[INFO] [stdout] 1945 | /             descriptor.get(|| {
[INFO] [stdout] 1946 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 1947 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
[INFO] [stdout] 1948 | |                     "Data",
[INFO] [stdout] ...    |
[INFO] [stdout] 1957 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1940 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1940 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1967:13
[INFO] [stdout]      |
[INFO] [stdout] 1967 |             instance.get(Payload::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1962 -         static mut instance: ::protobuf::lazy::Lazy<Payload> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1962 +         static instance: ::protobuf::lazy::Lazy<Payload> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2235:13
[INFO] [stdout]      |
[INFO] [stdout] 2235 | /             descriptor.get(|| {
[INFO] [stdout] 2236 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 2237 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
[INFO] [stdout] 2238 | |                     "start_ts",
[INFO] [stdout] ...    |
[INFO] [stdout] 2267 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2230 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2230 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2277:13
[INFO] [stdout]      |
[INFO] [stdout] 2277 |             instance.get(TxnContext::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2272 -         static mut instance: ::protobuf::lazy::Lazy<TxnContext> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2272 +         static instance: ::protobuf::lazy::Lazy<TxnContext> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2391:13
[INFO] [stdout]      |
[INFO] [stdout] 2391 | /             descriptor.get(|| {
[INFO] [stdout] 2392 | |                 let fields = ::std::vec::Vec::new();
[INFO] [stdout] 2393 | |                 ::protobuf::reflect::MessageDescriptor::new::<Check>(
[INFO] [stdout] 2394 | |                     "Check",
[INFO] [stdout] ...    |
[INFO] [stdout] 2398 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2386 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2386 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2408:13
[INFO] [stdout]      |
[INFO] [stdout] 2408 |             instance.get(Check::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2403 -         static mut instance: ::protobuf::lazy::Lazy<Check> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2403 +         static instance: ::protobuf::lazy::Lazy<Check> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2554:13
[INFO] [stdout]      |
[INFO] [stdout] 2554 | /             descriptor.get(|| {
[INFO] [stdout] 2555 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 2556 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 2557 | |                     "tag",
[INFO] [stdout] ...    |
[INFO] [stdout] 2566 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2549 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2549 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2576:13
[INFO] [stdout]      |
[INFO] [stdout] 2576 |             instance.get(Version::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2571 -         static mut instance: ::protobuf::lazy::Lazy<Version> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2571 +         static instance: ::protobuf::lazy::Lazy<Version> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2832:13
[INFO] [stdout]      |
[INFO] [stdout] 2832 | /             descriptor.get(|| {
[INFO] [stdout] 2833 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 2834 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
[INFO] [stdout] 2835 | |                     "parsing_ns",
[INFO] [stdout] ...    |
[INFO] [stdout] 2864 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2827 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2827 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2874:13
[INFO] [stdout]      |
[INFO] [stdout] 2874 |             instance.get(Latency::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2869 -         static mut instance: ::protobuf::lazy::Lazy<Latency> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2869 +         static instance: ::protobuf::lazy::Lazy<Latency> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3020:13
[INFO] [stdout]      |
[INFO] [stdout] 3020 | / ...   descriptor.get(|| {
[INFO] [stdout] 3021 | | ...       let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 3022 | | ...       fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::t...
[INFO] [stdout] 3023 | | ...           "num_uids",
[INFO] [stdout] ...    |
[INFO] [stdout] 3032 | | ...   })
[INFO] [stdout]      | |________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3015 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3015 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3042:13
[INFO] [stdout]      |
[INFO] [stdout] 3042 |             instance.get(Metrics::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3037 -         static mut instance: ::protobuf::lazy::Lazy<Metrics> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3037 +         static instance: ::protobuf::lazy::Lazy<Metrics> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3427:13
[INFO] [stdout]      |
[INFO] [stdout] 3427 | /             descriptor.get(|| {
[INFO] [stdout] 3428 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 3429 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 3430 | |                     "subject",
[INFO] [stdout] ...    |
[INFO] [stdout] 3469 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3422 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3422 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3479:13
[INFO] [stdout]      |
[INFO] [stdout] 3479 |             instance.get(NQuad::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3474 -         static mut instance: ::protobuf::lazy::Lazy<NQuad> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3474 +         static instance: ::protobuf::lazy::Lazy<NQuad> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4195:13
[INFO] [stdout]      |
[INFO] [stdout] 4195 | /             descriptor.get(|| {
[INFO] [stdout] 4196 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 4197 | |                 fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
[INFO] [stdout] 4198 | |                     "default_val",
[INFO] [stdout] ...    |
[INFO] [stdout] 4257 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4190 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4190 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4267:13
[INFO] [stdout]      |
[INFO] [stdout] 4267 |             instance.get(Value::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4262 -         static mut instance: ::protobuf::lazy::Lazy<Value> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4262 +         static instance: ::protobuf::lazy::Lazy<Value> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4556:13
[INFO] [stdout]      |
[INFO] [stdout] 4556 | /             descriptor.get(|| {
[INFO] [stdout] 4557 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 4558 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 4559 | |                     "key",
[INFO] [stdout] ...    |
[INFO] [stdout] 4588 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4551 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4551 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4598:13
[INFO] [stdout]      |
[INFO] [stdout] 4598 |             instance.get(Facet::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4593 -         static mut instance: ::protobuf::lazy::Lazy<Facet> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4593 +         static instance: ::protobuf::lazy::Lazy<Facet> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4668:13
[INFO] [stdout]      |
[INFO] [stdout] 4668 | /             descriptor.get(|| {
[INFO] [stdout] 4669 | |                 ::protobuf::reflect::EnumDescriptor::new("Facet_ValType", file_descriptor_proto())
[INFO] [stdout] 4670 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4663 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4663 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4885:13
[INFO] [stdout]      |
[INFO] [stdout] 4885 | /             descriptor.get(|| {
[INFO] [stdout] 4886 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 4887 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 4888 | |                     "userid",
[INFO] [stdout] ...    |
[INFO] [stdout] 4907 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4880 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4880 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4917:13
[INFO] [stdout]      |
[INFO] [stdout] 4917 |             instance.get(LoginRequest::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4912 -         static mut instance: ::protobuf::lazy::Lazy<LoginRequest> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4912 +         static instance: ::protobuf::lazy::Lazy<LoginRequest> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:5102:13
[INFO] [stdout]      |
[INFO] [stdout] 5102 | /             descriptor.get(|| {
[INFO] [stdout] 5103 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 5104 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 5105 | |                     "access_jwt",
[INFO] [stdout] ...    |
[INFO] [stdout] 5119 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 5097 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 5097 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:5129:13
[INFO] [stdout]      |
[INFO] [stdout] 5129 |             instance.get(Jwt::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 5124 -         static mut instance: ::protobuf::lazy::Lazy<Jwt> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 5124 +         static instance: ::protobuf::lazy::Lazy<Jwt> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:5242:9
[INFO] [stdout]      |
[INFO] [stdout] 5242 | /         file_descriptor_proto_lazy.get(|| {
[INFO] [stdout] 5243 | |             parse_descriptor_proto()
[INFO] [stdout] 5244 | |         })
[INFO] [stdout]      | |__________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 5231 - static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 5231 + static file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:342:13
[INFO] [stdout]     |
[INFO] [stdout] 342 | /             descriptor.get(|| {
[INFO] [stdout] 343 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 344 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
[INFO] [stdout] 345 | |                     "start_ts",
[INFO] [stdout] ...   |
[INFO] [stdout] 384 | |             })
[INFO] [stdout]     | |______________^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout]     = note: `--force-warn static-mut-refs` implied by `--force-warn rust-2024-compatibility`
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 337 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 337 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:394:13
[INFO] [stdout]     |
[INFO] [stdout] 394 |             instance.get(Request::new)
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 389 -         static mut instance: ::protobuf::lazy::Lazy<Request> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 389 +         static instance: ::protobuf::lazy::Lazy<Request> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:546:13
[INFO] [stdout]     |
[INFO] [stdout] 546 | /             descriptor.get(|| {
[INFO] [stdout] 547 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 548 | |                 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 549 | |                     "uids",
[INFO] [stdout] ...   |
[INFO] [stdout] 558 | |             })
[INFO] [stdout]     | |______________^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 541 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 541 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:568:13
[INFO] [stdout]     |
[INFO] [stdout] 568 |             instance.get(Uids::new)
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 563 -         static mut instance: ::protobuf::lazy::Lazy<Uids> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 563 +         static instance: ::protobuf::lazy::Lazy<Uids> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:899:13
[INFO] [stdout]     |
[INFO] [stdout] 899 | /             descriptor.get(|| {
[INFO] [stdout] 900 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 901 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
[INFO] [stdout] 902 | |                     "json",
[INFO] [stdout] ...   |
[INFO] [stdout] 931 | |             })
[INFO] [stdout]     | |______________^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 894 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 894 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:941:13
[INFO] [stdout]     |
[INFO] [stdout] 941 |             instance.get(Response::new)
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 936 -         static mut instance: ::protobuf::lazy::Lazy<Response> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 936 +         static instance: ::protobuf::lazy::Lazy<Response> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1351:13
[INFO] [stdout]      |
[INFO] [stdout] 1351 | /             descriptor.get(|| {
[INFO] [stdout] 1352 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 1353 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
[INFO] [stdout] 1354 | |                     "set_json",
[INFO] [stdout] ...    |
[INFO] [stdout] 1398 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1346 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1346 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1408:13
[INFO] [stdout]      |
[INFO] [stdout] 1408 |             instance.get(Mutation::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1403 -         static mut instance: ::protobuf::lazy::Lazy<Mutation> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1403 +         static instance: ::protobuf::lazy::Lazy<Mutation> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1688:13
[INFO] [stdout]      |
[INFO] [stdout] 1688 | /             descriptor.get(|| {
[INFO] [stdout] 1689 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 1690 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 1691 | |                     "schema",
[INFO] [stdout] ...    |
[INFO] [stdout] 1720 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1683 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1683 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1730:13
[INFO] [stdout]      |
[INFO] [stdout] 1730 |             instance.get(Operation::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1725 -         static mut instance: ::protobuf::lazy::Lazy<Operation> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1725 +         static instance: ::protobuf::lazy::Lazy<Operation> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1800:13
[INFO] [stdout]      |
[INFO] [stdout] 1800 | /             descriptor.get(|| {
[INFO] [stdout] 1801 | |                 ::protobuf::reflect::EnumDescriptor::new("Operation_DropOp", file_descriptor_proto())
[INFO] [stdout] 1802 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1795 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1795 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1945:13
[INFO] [stdout]      |
[INFO] [stdout] 1945 | /             descriptor.get(|| {
[INFO] [stdout] 1946 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 1947 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
[INFO] [stdout] 1948 | |                     "Data",
[INFO] [stdout] ...    |
[INFO] [stdout] 1957 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1940 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1940 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1967:13
[INFO] [stdout]      |
[INFO] [stdout] 1967 |             instance.get(Payload::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1962 -         static mut instance: ::protobuf::lazy::Lazy<Payload> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1962 +         static instance: ::protobuf::lazy::Lazy<Payload> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2235:13
[INFO] [stdout]      |
[INFO] [stdout] 2235 | /             descriptor.get(|| {
[INFO] [stdout] 2236 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 2237 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
[INFO] [stdout] 2238 | |                     "start_ts",
[INFO] [stdout] ...    |
[INFO] [stdout] 2267 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2230 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2230 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2277:13
[INFO] [stdout]      |
[INFO] [stdout] 2277 |             instance.get(TxnContext::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2272 -         static mut instance: ::protobuf::lazy::Lazy<TxnContext> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2272 +         static instance: ::protobuf::lazy::Lazy<TxnContext> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2391:13
[INFO] [stdout]      |
[INFO] [stdout] 2391 | /             descriptor.get(|| {
[INFO] [stdout] 2392 | |                 let fields = ::std::vec::Vec::new();
[INFO] [stdout] 2393 | |                 ::protobuf::reflect::MessageDescriptor::new::<Check>(
[INFO] [stdout] 2394 | |                     "Check",
[INFO] [stdout] ...    |
[INFO] [stdout] 2398 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2386 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2386 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2408:13
[INFO] [stdout]      |
[INFO] [stdout] 2408 |             instance.get(Check::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2403 -         static mut instance: ::protobuf::lazy::Lazy<Check> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2403 +         static instance: ::protobuf::lazy::Lazy<Check> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2554:13
[INFO] [stdout]      |
[INFO] [stdout] 2554 | /             descriptor.get(|| {
[INFO] [stdout] 2555 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 2556 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 2557 | |                     "tag",
[INFO] [stdout] ...    |
[INFO] [stdout] 2566 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2549 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2549 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2576:13
[INFO] [stdout]      |
[INFO] [stdout] 2576 |             instance.get(Version::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2571 -         static mut instance: ::protobuf::lazy::Lazy<Version> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2571 +         static instance: ::protobuf::lazy::Lazy<Version> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2832:13
[INFO] [stdout]      |
[INFO] [stdout] 2832 | /             descriptor.get(|| {
[INFO] [stdout] 2833 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 2834 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
[INFO] [stdout] 2835 | |                     "parsing_ns",
[INFO] [stdout] ...    |
[INFO] [stdout] 2864 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2827 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2827 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2874:13
[INFO] [stdout]      |
[INFO] [stdout] 2874 |             instance.get(Latency::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2869 -         static mut instance: ::protobuf::lazy::Lazy<Latency> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2869 +         static instance: ::protobuf::lazy::Lazy<Latency> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3020:13
[INFO] [stdout]      |
[INFO] [stdout] 3020 | / ...   descriptor.get(|| {
[INFO] [stdout] 3021 | | ...       let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 3022 | | ...       fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::t...
[INFO] [stdout] 3023 | | ...           "num_uids",
[INFO] [stdout] ...    |
[INFO] [stdout] 3032 | | ...   })
[INFO] [stdout]      | |________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3015 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3015 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3042:13
[INFO] [stdout]      |
[INFO] [stdout] 3042 |             instance.get(Metrics::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3037 -         static mut instance: ::protobuf::lazy::Lazy<Metrics> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3037 +         static instance: ::protobuf::lazy::Lazy<Metrics> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3427:13
[INFO] [stdout]      |
[INFO] [stdout] 3427 | /             descriptor.get(|| {
[INFO] [stdout] 3428 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 3429 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 3430 | |                     "subject",
[INFO] [stdout] ...    |
[INFO] [stdout] 3469 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3422 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3422 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished `dev` profile [unoptimized + debuginfo] target(s) in 32.69s
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3479:13
[INFO] [stdout]      |
[INFO] [stdout] 3479 |             instance.get(NQuad::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3474 -         static mut instance: ::protobuf::lazy::Lazy<NQuad> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3474 +         static instance: ::protobuf::lazy::Lazy<NQuad> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] crater-edition-check: dgraph-rs v0.2.8 (/opt/rustwide/workdir) updating edition from 2021 to 2024
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4195:13
[INFO] [stdout]      |
[INFO] [stdout] 4195 | /             descriptor.get(|| {
[INFO] [stdout] 4196 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 4197 | |                 fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
[INFO] [stdout] 4198 | |                     "default_val",
[INFO] [stdout] ...    |
[INFO] [stdout] 4257 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4190 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4190 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4267:13
[INFO] [stdout]      |
[INFO] [stdout] 4267 |             instance.get(Value::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4262 -         static mut instance: ::protobuf::lazy::Lazy<Value> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4262 +         static instance: ::protobuf::lazy::Lazy<Value> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4556:13
[INFO] [stdout]      |
[INFO] [stdout] 4556 | /             descriptor.get(|| {
[INFO] [stdout] 4557 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 4558 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 4559 | |                     "key",
[INFO] [stdout] ...    |
[INFO] [stdout] 4588 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4551 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4551 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4598:13
[INFO] [stdout]      |
[INFO] [stdout] 4598 |             instance.get(Facet::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4593 -         static mut instance: ::protobuf::lazy::Lazy<Facet> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4593 +         static instance: ::protobuf::lazy::Lazy<Facet> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4668:13
[INFO] [stdout]      |
[INFO] [stdout] 4668 | /             descriptor.get(|| {
[INFO] [stdout] 4669 | |                 ::protobuf::reflect::EnumDescriptor::new("Facet_ValType", file_descriptor_proto())
[INFO] [stdout] 4670 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4663 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4663 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4885:13
[INFO] [stdout]      |
[INFO] [stdout] 4885 | /             descriptor.get(|| {
[INFO] [stdout] 4886 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 4887 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 4888 | |                     "userid",
[INFO] [stdout] ...    |
[INFO] [stdout] 4907 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4880 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4880 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4917:13
[INFO] [stdout]      |
[INFO] [stdout] 4917 |             instance.get(LoginRequest::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4912 -         static mut instance: ::protobuf::lazy::Lazy<LoginRequest> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4912 +         static instance: ::protobuf::lazy::Lazy<LoginRequest> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:5102:13
[INFO] [stdout]      |
[INFO] [stdout] 5102 | /             descriptor.get(|| {
[INFO] [stdout] 5103 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 5104 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 5105 | |                     "access_jwt",
[INFO] [stdout] ...    |
[INFO] [stdout] 5119 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 5097 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 5097 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:5129:13
[INFO] [stdout]      |
[INFO] [stdout] 5129 |             instance.get(Jwt::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 5124 -         static mut instance: ::protobuf::lazy::Lazy<Jwt> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 5124 +         static instance: ::protobuf::lazy::Lazy<Jwt> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:5242:9
[INFO] [stdout]      |
[INFO] [stdout] 5242 | /         file_descriptor_proto_lazy.get(|| {
[INFO] [stdout] 5243 | |             parse_descriptor_proto()
[INFO] [stdout] 5244 | |         })
[INFO] [stdout]      | |__________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 5231 - static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 5231 + static file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]    Compiling dgraph-rs v0.2.8 (/opt/rustwide/workdir)
[INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]   --> src/lib.rs:41:20
[INFO] [stdout]    |
[INFO] [stdout] 41 |     pub fn new_txn(&self) -> Txn {
[INFO] [stdout]    |                    ^^^^^     ^^^ the same lifetime is hidden here
[INFO] [stdout]    |                    |
[INFO] [stdout]    |                    the lifetime is elided here
[INFO] [stdout]    |
[INFO] [stdout]    = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
[INFO] [stdout]    = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default
[INFO] [stdout] help: use `'_` for type paths
[INFO] [stdout]    |
[INFO] [stdout] 41 |     pub fn new_txn(&self) -> Txn<'_> {
[INFO] [stdout]    |                                 ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]   --> src/lib.rs:53:26
[INFO] [stdout]    |
[INFO] [stdout] 53 |     pub fn new_read_only(&self) -> Txn {
[INFO] [stdout]    |                          ^^^^^     ^^^ the same lifetime is hidden here
[INFO] [stdout]    |                          |
[INFO] [stdout]    |                          the lifetime is elided here
[INFO] [stdout]    |
[INFO] [stdout]    = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
[INFO] [stdout] help: use `'_` for type paths
[INFO] [stdout]    |
[INFO] [stdout] 53 |     pub fn new_read_only(&self) -> Txn<'_> {
[INFO] [stdout]    |                                       ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]   --> src/lib.rs:65:28
[INFO] [stdout]    |
[INFO] [stdout] 65 |     pub fn new_best_effort(&self) -> Txn {
[INFO] [stdout]    |                            ^^^^^     ^^^ the same lifetime is hidden here
[INFO] [stdout]    |                            |
[INFO] [stdout]    |                            the lifetime is elided here
[INFO] [stdout]    |
[INFO] [stdout]    = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
[INFO] [stdout] help: use `'_` for type paths
[INFO] [stdout]    |
[INFO] [stdout] 65 |     pub fn new_best_effort(&self) -> Txn<'_> {
[INFO] [stdout]    |                                         ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:342:13
[INFO] [stdout]     |
[INFO] [stdout] 342 | /             descriptor.get(|| {
[INFO] [stdout] 343 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 344 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
[INFO] [stdout] 345 | |                     "start_ts",
[INFO] [stdout] ...   |
[INFO] [stdout] 384 | |             })
[INFO] [stdout]     | |______________^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout]     = note: `#[deny(static_mut_refs)]` (part of `#[deny(rust_2024_compatibility)]`) on by default
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 337 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 337 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:394:13
[INFO] [stdout]     |
[INFO] [stdout] 394 |             instance.get(Request::new)
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 389 -         static mut instance: ::protobuf::lazy::Lazy<Request> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 389 +         static instance: ::protobuf::lazy::Lazy<Request> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:546:13
[INFO] [stdout]     |
[INFO] [stdout] 546 | /             descriptor.get(|| {
[INFO] [stdout] 547 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 548 | |                 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 549 | |                     "uids",
[INFO] [stdout] ...   |
[INFO] [stdout] 558 | |             })
[INFO] [stdout]     | |______________^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 541 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 541 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:568:13
[INFO] [stdout]     |
[INFO] [stdout] 568 |             instance.get(Uids::new)
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 563 -         static mut instance: ::protobuf::lazy::Lazy<Uids> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 563 +         static instance: ::protobuf::lazy::Lazy<Uids> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:899:13
[INFO] [stdout]     |
[INFO] [stdout] 899 | /             descriptor.get(|| {
[INFO] [stdout] 900 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 901 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
[INFO] [stdout] 902 | |                     "json",
[INFO] [stdout] ...   |
[INFO] [stdout] 931 | |             })
[INFO] [stdout]     | |______________^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 894 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 894 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:941:13
[INFO] [stdout]     |
[INFO] [stdout] 941 |             instance.get(Response::new)
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 936 -         static mut instance: ::protobuf::lazy::Lazy<Response> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 936 +         static instance: ::protobuf::lazy::Lazy<Response> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1351:13
[INFO] [stdout]      |
[INFO] [stdout] 1351 | /             descriptor.get(|| {
[INFO] [stdout] 1352 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 1353 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
[INFO] [stdout] 1354 | |                     "set_json",
[INFO] [stdout] ...    |
[INFO] [stdout] 1398 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1346 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1346 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1408:13
[INFO] [stdout]      |
[INFO] [stdout] 1408 |             instance.get(Mutation::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1403 -         static mut instance: ::protobuf::lazy::Lazy<Mutation> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1403 +         static instance: ::protobuf::lazy::Lazy<Mutation> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1688:13
[INFO] [stdout]      |
[INFO] [stdout] 1688 | /             descriptor.get(|| {
[INFO] [stdout] 1689 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 1690 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 1691 | |                     "schema",
[INFO] [stdout] ...    |
[INFO] [stdout] 1720 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1683 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1683 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1730:13
[INFO] [stdout]      |
[INFO] [stdout] 1730 |             instance.get(Operation::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1725 -         static mut instance: ::protobuf::lazy::Lazy<Operation> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1725 +         static instance: ::protobuf::lazy::Lazy<Operation> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1800:13
[INFO] [stdout]      |
[INFO] [stdout] 1800 | /             descriptor.get(|| {
[INFO] [stdout] 1801 | |                 ::protobuf::reflect::EnumDescriptor::new("Operation_DropOp", file_descriptor_proto())
[INFO] [stdout] 1802 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1795 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1795 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1945:13
[INFO] [stdout]      |
[INFO] [stdout] 1945 | /             descriptor.get(|| {
[INFO] [stdout] 1946 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 1947 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
[INFO] [stdout] 1948 | |                     "Data",
[INFO] [stdout] ...    |
[INFO] [stdout] 1957 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1940 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1940 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1967:13
[INFO] [stdout]      |
[INFO] [stdout] 1967 |             instance.get(Payload::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1962 -         static mut instance: ::protobuf::lazy::Lazy<Payload> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1962 +         static instance: ::protobuf::lazy::Lazy<Payload> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2235:13
[INFO] [stdout]      |
[INFO] [stdout] 2235 | /             descriptor.get(|| {
[INFO] [stdout] 2236 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 2237 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
[INFO] [stdout] 2238 | |                     "start_ts",
[INFO] [stdout] ...    |
[INFO] [stdout] 2267 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2230 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2230 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2277:13
[INFO] [stdout]      |
[INFO] [stdout] 2277 |             instance.get(TxnContext::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2272 -         static mut instance: ::protobuf::lazy::Lazy<TxnContext> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2272 +         static instance: ::protobuf::lazy::Lazy<TxnContext> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2391:13
[INFO] [stdout]      |
[INFO] [stdout] 2391 | /             descriptor.get(|| {
[INFO] [stdout] 2392 | |                 let fields = ::std::vec::Vec::new();
[INFO] [stdout] 2393 | |                 ::protobuf::reflect::MessageDescriptor::new::<Check>(
[INFO] [stdout] 2394 | |                     "Check",
[INFO] [stdout] ...    |
[INFO] [stdout] 2398 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2386 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2386 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2408:13
[INFO] [stdout]      |
[INFO] [stdout] 2408 |             instance.get(Check::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2403 -         static mut instance: ::protobuf::lazy::Lazy<Check> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2403 +         static instance: ::protobuf::lazy::Lazy<Check> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2554:13
[INFO] [stdout]      |
[INFO] [stdout] 2554 | /             descriptor.get(|| {
[INFO] [stdout] 2555 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 2556 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 2557 | |                     "tag",
[INFO] [stdout] ...    |
[INFO] [stdout] 2566 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2549 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2549 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2576:13
[INFO] [stdout]      |
[INFO] [stdout] 2576 |             instance.get(Version::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2571 -         static mut instance: ::protobuf::lazy::Lazy<Version> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2571 +         static instance: ::protobuf::lazy::Lazy<Version> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2832:13
[INFO] [stdout]      |
[INFO] [stdout] 2832 | /             descriptor.get(|| {
[INFO] [stdout] 2833 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 2834 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
[INFO] [stdout] 2835 | |                     "parsing_ns",
[INFO] [stdout] ...    |
[INFO] [stdout] 2864 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2827 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2827 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2874:13
[INFO] [stdout]      |
[INFO] [stdout] 2874 |             instance.get(Latency::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2869 -         static mut instance: ::protobuf::lazy::Lazy<Latency> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2869 +         static instance: ::protobuf::lazy::Lazy<Latency> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3020:13
[INFO] [stdout]      |
[INFO] [stdout] 3020 | / ...   descriptor.get(|| {
[INFO] [stdout] 3021 | | ...       let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 3022 | | ...       fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::t...
[INFO] [stdout] 3023 | | ...           "num_uids",
[INFO] [stdout] ...    |
[INFO] [stdout] 3032 | | ...   })
[INFO] [stdout]      | |________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3015 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3015 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3042:13
[INFO] [stdout]      |
[INFO] [stdout] 3042 |             instance.get(Metrics::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3037 -         static mut instance: ::protobuf::lazy::Lazy<Metrics> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3037 +         static instance: ::protobuf::lazy::Lazy<Metrics> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3427:13
[INFO] [stdout]      |
[INFO] [stdout] 3427 | /             descriptor.get(|| {
[INFO] [stdout] 3428 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 3429 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 3430 | |                     "subject",
[INFO] [stdout] ...    |
[INFO] [stdout] 3469 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3422 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3422 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3479:13
[INFO] [stdout]      |
[INFO] [stdout] 3479 |             instance.get(NQuad::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3474 -         static mut instance: ::protobuf::lazy::Lazy<NQuad> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3474 +         static instance: ::protobuf::lazy::Lazy<NQuad> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4195:13
[INFO] [stdout]      |
[INFO] [stdout] 4195 | /             descriptor.get(|| {
[INFO] [stdout] 4196 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 4197 | |                 fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
[INFO] [stdout] 4198 | |                     "default_val",
[INFO] [stdout] ...    |
[INFO] [stdout] 4257 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4190 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4190 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4267:13
[INFO] [stdout]      |
[INFO] [stdout] 4267 |             instance.get(Value::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4262 -         static mut instance: ::protobuf::lazy::Lazy<Value> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4262 +         static instance: ::protobuf::lazy::Lazy<Value> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4556:13
[INFO] [stdout]      |
[INFO] [stdout] 4556 | /             descriptor.get(|| {
[INFO] [stdout] 4557 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 4558 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 4559 | |                     "key",
[INFO] [stdout] ...    |
[INFO] [stdout] 4588 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4551 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4551 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4598:13
[INFO] [stdout]      |
[INFO] [stdout] 4598 |             instance.get(Facet::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4593 -         static mut instance: ::protobuf::lazy::Lazy<Facet> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4593 +         static instance: ::protobuf::lazy::Lazy<Facet> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4668:13
[INFO] [stdout]      |
[INFO] [stdout] 4668 | /             descriptor.get(|| {
[INFO] [stdout] 4669 | |                 ::protobuf::reflect::EnumDescriptor::new("Facet_ValType", file_descriptor_proto())
[INFO] [stdout] 4670 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4663 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4663 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4885:13
[INFO] [stdout]      |
[INFO] [stdout] 4885 | /             descriptor.get(|| {
[INFO] [stdout] 4886 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 4887 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 4888 | |                     "userid",
[INFO] [stdout] ...    |
[INFO] [stdout] 4907 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4880 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4880 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4917:13
[INFO] [stdout]      |
[INFO] [stdout] 4917 |             instance.get(LoginRequest::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4912 -         static mut instance: ::protobuf::lazy::Lazy<LoginRequest> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4912 +         static instance: ::protobuf::lazy::Lazy<LoginRequest> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:5102:13
[INFO] [stdout]      |
[INFO] [stdout] 5102 | /             descriptor.get(|| {
[INFO] [stdout] 5103 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 5104 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 5105 | |                     "access_jwt",
[INFO] [stdout] ...    |
[INFO] [stdout] 5119 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 5097 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 5097 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:5129:13
[INFO] [stdout]      |
[INFO] [stdout] 5129 |             instance.get(Jwt::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 5124 -         static mut instance: ::protobuf::lazy::Lazy<Jwt> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 5124 +         static instance: ::protobuf::lazy::Lazy<Jwt> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:5242:9
[INFO] [stdout]      |
[INFO] [stdout] 5242 | /         file_descriptor_proto_lazy.get(|| {
[INFO] [stdout] 5243 | |             parse_descriptor_proto()
[INFO] [stdout] 5244 | |         })
[INFO] [stdout]      | |__________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 5231 - static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 5231 + static file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]   --> src/lib.rs:41:20
[INFO] [stdout]    |
[INFO] [stdout] 41 |     pub fn new_txn(&self) -> Txn {
[INFO] [stdout]    |                    ^^^^^     ^^^ the same lifetime is hidden here
[INFO] [stdout]    |                    |
[INFO] [stdout]    |                    the lifetime is elided here
[INFO] [stdout]    |
[INFO] [stdout]    = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
[INFO] [stdout]    = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default
[INFO] [stdout] help: use `'_` for type paths
[INFO] [stdout]    |
[INFO] [stdout] 41 |     pub fn new_txn(&self) -> Txn<'_> {
[INFO] [stdout]    |                                 ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]   --> src/lib.rs:53:26
[INFO] [stdout]    |
[INFO] [stdout] 53 |     pub fn new_read_only(&self) -> Txn {
[INFO] [stdout]    |                          ^^^^^     ^^^ the same lifetime is hidden here
[INFO] [stdout]    |                          |
[INFO] [stdout]    |                          the lifetime is elided here
[INFO] [stdout]    |
[INFO] [stdout]    = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
[INFO] [stdout] help: use `'_` for type paths
[INFO] [stdout]    |
[INFO] [stdout] 53 |     pub fn new_read_only(&self) -> Txn<'_> {
[INFO] [stdout]    |                                       ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: hiding a lifetime that's elided elsewhere is confusing
[INFO] [stdout]   --> src/lib.rs:65:28
[INFO] [stdout]    |
[INFO] [stdout] 65 |     pub fn new_best_effort(&self) -> Txn {
[INFO] [stdout]    |                            ^^^^^     ^^^ the same lifetime is hidden here
[INFO] [stdout]    |                            |
[INFO] [stdout]    |                            the lifetime is elided here
[INFO] [stdout]    |
[INFO] [stdout]    = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
[INFO] [stdout] help: use `'_` for type paths
[INFO] [stdout]    |
[INFO] [stdout] 65 |     pub fn new_best_effort(&self) -> Txn<'_> {
[INFO] [stdout]    |                                         ++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `dgraph-rs` (lib) due to 35 previous errors; 3 warnings emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:342:13
[INFO] [stdout]     |
[INFO] [stdout] 342 | /             descriptor.get(|| {
[INFO] [stdout] 343 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 344 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
[INFO] [stdout] 345 | |                     "start_ts",
[INFO] [stdout] ...   |
[INFO] [stdout] 384 | |             })
[INFO] [stdout]     | |______________^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout]     = note: `#[deny(static_mut_refs)]` (part of `#[deny(rust_2024_compatibility)]`) on by default
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 337 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 337 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:394:13
[INFO] [stdout]     |
[INFO] [stdout] 394 |             instance.get(Request::new)
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 389 -         static mut instance: ::protobuf::lazy::Lazy<Request> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 389 +         static instance: ::protobuf::lazy::Lazy<Request> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:546:13
[INFO] [stdout]     |
[INFO] [stdout] 546 | /             descriptor.get(|| {
[INFO] [stdout] 547 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 548 | |                 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 549 | |                     "uids",
[INFO] [stdout] ...   |
[INFO] [stdout] 558 | |             })
[INFO] [stdout]     | |______________^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 541 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 541 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:568:13
[INFO] [stdout]     |
[INFO] [stdout] 568 |             instance.get(Uids::new)
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 563 -         static mut instance: ::protobuf::lazy::Lazy<Uids> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 563 +         static instance: ::protobuf::lazy::Lazy<Uids> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:899:13
[INFO] [stdout]     |
[INFO] [stdout] 899 | /             descriptor.get(|| {
[INFO] [stdout] 900 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 901 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
[INFO] [stdout] 902 | |                     "json",
[INFO] [stdout] ...   |
[INFO] [stdout] 931 | |             })
[INFO] [stdout]     | |______________^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 894 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 894 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]    --> src/protos/api.rs:941:13
[INFO] [stdout]     |
[INFO] [stdout] 941 |             instance.get(Response::new)
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]     |
[INFO] [stdout]     = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]     |
[INFO] [stdout] 936 -         static mut instance: ::protobuf::lazy::Lazy<Response> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 936 +         static instance: ::protobuf::lazy::Lazy<Response> = ::protobuf::lazy::Lazy {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1351:13
[INFO] [stdout]      |
[INFO] [stdout] 1351 | /             descriptor.get(|| {
[INFO] [stdout] 1352 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 1353 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
[INFO] [stdout] 1354 | |                     "set_json",
[INFO] [stdout] ...    |
[INFO] [stdout] 1398 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1346 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1346 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1408:13
[INFO] [stdout]      |
[INFO] [stdout] 1408 |             instance.get(Mutation::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1403 -         static mut instance: ::protobuf::lazy::Lazy<Mutation> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1403 +         static instance: ::protobuf::lazy::Lazy<Mutation> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1688:13
[INFO] [stdout]      |
[INFO] [stdout] 1688 | /             descriptor.get(|| {
[INFO] [stdout] 1689 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 1690 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 1691 | |                     "schema",
[INFO] [stdout] ...    |
[INFO] [stdout] 1720 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1683 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1683 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1730:13
[INFO] [stdout]      |
[INFO] [stdout] 1730 |             instance.get(Operation::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1725 -         static mut instance: ::protobuf::lazy::Lazy<Operation> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1725 +         static instance: ::protobuf::lazy::Lazy<Operation> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1800:13
[INFO] [stdout]      |
[INFO] [stdout] 1800 | /             descriptor.get(|| {
[INFO] [stdout] 1801 | |                 ::protobuf::reflect::EnumDescriptor::new("Operation_DropOp", file_descriptor_proto())
[INFO] [stdout] 1802 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1795 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1795 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1945:13
[INFO] [stdout]      |
[INFO] [stdout] 1945 | /             descriptor.get(|| {
[INFO] [stdout] 1946 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 1947 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
[INFO] [stdout] 1948 | |                     "Data",
[INFO] [stdout] ...    |
[INFO] [stdout] 1957 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1940 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1940 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:1967:13
[INFO] [stdout]      |
[INFO] [stdout] 1967 |             instance.get(Payload::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 1962 -         static mut instance: ::protobuf::lazy::Lazy<Payload> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 1962 +         static instance: ::protobuf::lazy::Lazy<Payload> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2235:13
[INFO] [stdout]      |
[INFO] [stdout] 2235 | /             descriptor.get(|| {
[INFO] [stdout] 2236 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 2237 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
[INFO] [stdout] 2238 | |                     "start_ts",
[INFO] [stdout] ...    |
[INFO] [stdout] 2267 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2230 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2230 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2277:13
[INFO] [stdout]      |
[INFO] [stdout] 2277 |             instance.get(TxnContext::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2272 -         static mut instance: ::protobuf::lazy::Lazy<TxnContext> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2272 +         static instance: ::protobuf::lazy::Lazy<TxnContext> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2391:13
[INFO] [stdout]      |
[INFO] [stdout] 2391 | /             descriptor.get(|| {
[INFO] [stdout] 2392 | |                 let fields = ::std::vec::Vec::new();
[INFO] [stdout] 2393 | |                 ::protobuf::reflect::MessageDescriptor::new::<Check>(
[INFO] [stdout] 2394 | |                     "Check",
[INFO] [stdout] ...    |
[INFO] [stdout] 2398 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2386 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2386 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2408:13
[INFO] [stdout]      |
[INFO] [stdout] 2408 |             instance.get(Check::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2403 -         static mut instance: ::protobuf::lazy::Lazy<Check> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2403 +         static instance: ::protobuf::lazy::Lazy<Check> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2554:13
[INFO] [stdout]      |
[INFO] [stdout] 2554 | /             descriptor.get(|| {
[INFO] [stdout] 2555 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 2556 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 2557 | |                     "tag",
[INFO] [stdout] ...    |
[INFO] [stdout] 2566 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2549 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2549 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2576:13
[INFO] [stdout]      |
[INFO] [stdout] 2576 |             instance.get(Version::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2571 -         static mut instance: ::protobuf::lazy::Lazy<Version> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2571 +         static instance: ::protobuf::lazy::Lazy<Version> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2832:13
[INFO] [stdout]      |
[INFO] [stdout] 2832 | /             descriptor.get(|| {
[INFO] [stdout] 2833 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 2834 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
[INFO] [stdout] 2835 | |                     "parsing_ns",
[INFO] [stdout] ...    |
[INFO] [stdout] 2864 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2827 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2827 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:2874:13
[INFO] [stdout]      |
[INFO] [stdout] 2874 |             instance.get(Latency::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 2869 -         static mut instance: ::protobuf::lazy::Lazy<Latency> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 2869 +         static instance: ::protobuf::lazy::Lazy<Latency> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3020:13
[INFO] [stdout]      |
[INFO] [stdout] 3020 | / ...   descriptor.get(|| {
[INFO] [stdout] 3021 | | ...       let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 3022 | | ...       fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::t...
[INFO] [stdout] 3023 | | ...           "num_uids",
[INFO] [stdout] ...    |
[INFO] [stdout] 3032 | | ...   })
[INFO] [stdout]      | |________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3015 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3015 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3042:13
[INFO] [stdout]      |
[INFO] [stdout] 3042 |             instance.get(Metrics::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3037 -         static mut instance: ::protobuf::lazy::Lazy<Metrics> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3037 +         static instance: ::protobuf::lazy::Lazy<Metrics> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3427:13
[INFO] [stdout]      |
[INFO] [stdout] 3427 | /             descriptor.get(|| {
[INFO] [stdout] 3428 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 3429 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 3430 | |                     "subject",
[INFO] [stdout] ...    |
[INFO] [stdout] 3469 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3422 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3422 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:3479:13
[INFO] [stdout]      |
[INFO] [stdout] 3479 |             instance.get(NQuad::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 3474 -         static mut instance: ::protobuf::lazy::Lazy<NQuad> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 3474 +         static instance: ::protobuf::lazy::Lazy<NQuad> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4195:13
[INFO] [stdout]      |
[INFO] [stdout] 4195 | /             descriptor.get(|| {
[INFO] [stdout] 4196 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 4197 | |                 fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
[INFO] [stdout] 4198 | |                     "default_val",
[INFO] [stdout] ...    |
[INFO] [stdout] 4257 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4190 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4190 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4267:13
[INFO] [stdout]      |
[INFO] [stdout] 4267 |             instance.get(Value::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4262 -         static mut instance: ::protobuf::lazy::Lazy<Value> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4262 +         static instance: ::protobuf::lazy::Lazy<Value> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4556:13
[INFO] [stdout]      |
[INFO] [stdout] 4556 | /             descriptor.get(|| {
[INFO] [stdout] 4557 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 4558 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 4559 | |                     "key",
[INFO] [stdout] ...    |
[INFO] [stdout] 4588 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4551 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4551 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4598:13
[INFO] [stdout]      |
[INFO] [stdout] 4598 |             instance.get(Facet::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4593 -         static mut instance: ::protobuf::lazy::Lazy<Facet> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4593 +         static instance: ::protobuf::lazy::Lazy<Facet> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4668:13
[INFO] [stdout]      |
[INFO] [stdout] 4668 | /             descriptor.get(|| {
[INFO] [stdout] 4669 | |                 ::protobuf::reflect::EnumDescriptor::new("Facet_ValType", file_descriptor_proto())
[INFO] [stdout] 4670 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4663 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4663 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4885:13
[INFO] [stdout]      |
[INFO] [stdout] 4885 | /             descriptor.get(|| {
[INFO] [stdout] 4886 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 4887 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 4888 | |                     "userid",
[INFO] [stdout] ...    |
[INFO] [stdout] 4907 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4880 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4880 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:4917:13
[INFO] [stdout]      |
[INFO] [stdout] 4917 |             instance.get(LoginRequest::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 4912 -         static mut instance: ::protobuf::lazy::Lazy<LoginRequest> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 4912 +         static instance: ::protobuf::lazy::Lazy<LoginRequest> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:5102:13
[INFO] [stdout]      |
[INFO] [stdout] 5102 | /             descriptor.get(|| {
[INFO] [stdout] 5103 | |                 let mut fields = ::std::vec::Vec::new();
[INFO] [stdout] 5104 | |                 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
[INFO] [stdout] 5105 | |                     "access_jwt",
[INFO] [stdout] ...    |
[INFO] [stdout] 5119 | |             })
[INFO] [stdout]      | |______________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 5097 -         static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 5097 +         static descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:5129:13
[INFO] [stdout]      |
[INFO] [stdout] 5129 |             instance.get(Jwt::new)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 5124 -         static mut instance: ::protobuf::lazy::Lazy<Jwt> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 5124 +         static instance: ::protobuf::lazy::Lazy<Jwt> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: creating a mutable reference to mutable static
[INFO] [stdout]     --> src/protos/api.rs:5242:9
[INFO] [stdout]      |
[INFO] [stdout] 5242 | /         file_descriptor_proto_lazy.get(|| {
[INFO] [stdout] 5243 | |             parse_descriptor_proto()
[INFO] [stdout] 5244 | |         })
[INFO] [stdout]      | |__________^ mutable reference to mutable static
[INFO] [stdout]      |
[INFO] [stdout]      = note: mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/static-mut-references.html>
[INFO] [stdout] help: this type already provides "interior mutability", so its binding doesn't need to be declared as mutable
[INFO] [stdout]      |
[INFO] [stdout] 5231 - static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
[INFO] [stdout] 5231 + static file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `dgraph-rs` (lib test) due to 35 previous errors; 3 warnings emitted
[INFO] running `Command { std: "docker" "inspect" "f20f0ad1249e0cb79f7941d291ebc3ef7f15f225348a0d5d76aaeb728285a799", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "f20f0ad1249e0cb79f7941d291ebc3ef7f15f225348a0d5d76aaeb728285a799", kill_on_drop: false }`
[INFO] [stdout] f20f0ad1249e0cb79f7941d291ebc3ef7f15f225348a0d5d76aaeb728285a799
